package com.xky.example_student.controller.login;

import com.xky.example_student.entity.User;
import com.xky.example_student.entity.Result;
import com.xky.example_student.service.LoginService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;
import java.util.HashMap;

@Slf4j
@RestController
@RequestMapping("/api/Login")
@Tag(name = "用户信息管理")
public class LoginController {

    @Autowired
    private LoginService loginService;

    /**
     * 用户注册
     * @param user
     * @return
     */
    @PostMapping("/save")
    @Operation(summary = "用户注册信息")
    public Result<String> save(@RequestBody User user){
        log.info("用户注册信息: username={}, role={}, password={}", 
                user.getUsername(), user.getRole(), 
                user.getPassword() != null ? "***" : "null");
        return loginService.saveUser(user);
    }

    /**
     * 用户注销功能的实现
     * @param id
     * @return
     */
    @DeleteMapping("/remove")
    @Operation(summary = "用户注销")
    public Result<String> removeUser(@RequestParam Integer id){
        log.info("注销id为{}的用户",id);
        boolean b = loginService.removeById(id);
        if (b){
            return Result.success("id为"+id+"的用户注销成功");
        }else {
            return Result.error("未知错误，请检查");
        }
    }

    @PostMapping("/update")
    @Operation(summary = "用户信息修改")
    public Result<Boolean> updateUser(@RequestBody User user){
        log.info("用户信息修改{}",user);
        boolean b = loginService.updateById(user);
        if (b){
            return Result.success();
        }else {
            return Result.error("未知错误，请检查");
        }
    }

    @PostMapping("/login")
    @Operation(summary = "用户登录")
    public Result<User> loginUser(@RequestBody User user){
        log.info("用户登录: username={}, role={}", user.getUsername(), user.getRole());
        User isuser = loginService.getUser(user);
        if (isuser == null){
            log.warn("登录失败: 未找到匹配的用户");
            return Result.error("用户名或密码错误");
        }else {
            log.info("登录成功: 用户ID={}, 角色={}", isuser.getId(), isuser.getRole());
            return Result.success(isuser);
        }
    }
    
    /**
     * 用户退出登录
     * @param username 用户名
     * @return 操作结果
     */
    @GetMapping("/logout")
    @Operation(summary = "用户退出登录")
    public Result<String> logout(@RequestParam String username){
        log.info("用户退出登录: username={}", username);
        // 在实际项目中，这里可以清除Redis中的token或将token加入黑名单
        // 当前简化实现，仅记录日志
        return Result.success("退出登录成功");
    }
    
    @GetMapping("/checkUsername")
    @Operation(summary = "检查用户名是否存在")
    public Result<Boolean> checkUsername(@RequestParam String username){
        log.info("检查用户名: {}", username);
        boolean exists = loginService.isUsernameExists(username);
        return Result.success(exists);
    }
    
    @GetMapping("/userInfo")
    @Operation(summary = "获取用户信息")
    public Result<User> getUserInfo(@RequestParam String username){
        log.info("获取用户信息 username={}", username);
        User user = loginService.getUserByUsername(username);
        if (user != null) {
            // 不返回密码
            user.setPassword(null);
            return Result.success(user);
        } else {
            return Result.error("用户不存在");
        }
    }
    
    @PostMapping("/updateEditPermission")
    @Operation(summary = "更新用户编辑权限")
    public Result<String> updateEditPermission(@RequestParam Integer userId, @RequestParam Boolean canEditProfile){
        log.info("更新用户编辑权限: userId={}, canEditProfile={}", userId, canEditProfile);
        User user = loginService.getById(userId);
        if (user == null) {
            return Result.error("用户不存在");
        }
        user.setCanEditProfile(canEditProfile);
        boolean success = loginService.updateById(user);

        // 不再需要同步更新学生表权限

        if (success) {
            return Result.success("权限更新成功");
        } else {
            return Result.error("权限更新失败");
        }
    }
    
    @GetMapping("/getAllUsers")
    @Operation(summary = "获取所有用户信息（管理员专用）")
    public Result<List<User>> getAllUsers(){
        log.info("获取所有用户信息");
        List<User> users = loginService.list();
        // 不返回密码
        users.forEach(user -> user.setPassword(null));
        return Result.success(users);
    }

    /**
     * 批量更新用户编辑权限
     * @param params 包含用户ID列表和权限状态的参数
     * @return 操作结果
     */
    @PostMapping("/batchUpdateEditPermission")
    @Operation(summary = "批量更新用户编辑权限")
    public Result<String> batchUpdateEditPermission(@RequestBody Map<String, Object> params) {
        log.info("批量更新用户编辑权限: {}", params);
        
        List<Integer> userIds = (List<Integer>) params.get("userIds");
        Boolean canEditProfile = (Boolean) params.get("canEditProfile");
        
        if (userIds == null || userIds.isEmpty() || canEditProfile == null) {
            return Result.error("参数错误");
        }
        
        int successCount = 0;
        for (Integer userId : userIds) {
            User user = loginService.getById(userId);
            if (user != null && !"admin".equals(user.getRole())) { // 不允许修改管理员权限
                user.setCanEditProfile(canEditProfile);
                if (loginService.updateById(user)) {
                    successCount++;

                    // 不再需要同步更新学生表权限
                }
            }
        }
        
        return Result.success("成功更新 " + successCount + " 个用户的权限");
    }
    
    /**
     * 登录调试接口
     * @return 登录相关的调试信息
     */
    @GetMapping("/debug")
    @Operation(summary = "登录调试接口")
    public Result<Map<String, Object>> loginDebug() {
        try {
            Map<String, Object> debugInfo = new HashMap<>();
            
            // 获取所有用户信息（隐藏密码）
            List<User> allUsers = loginService.list();
            allUsers.forEach(user -> {
                // 记录原密码长度但不显示密码内容
                String passwordInfo = user.getPassword() != null ? 
                    String.format("长度:%d, 格式:%s", 
                        user.getPassword().length(),
                        user.getPassword().length() == 32 ? "MD5" : "其他"
                    ) : "无密码";
                user.setPassword(passwordInfo);
            });
            debugInfo.put("allUsers", allUsers);
            
            // 统计用户角色分布
            Map<String, Long> roleCount = allUsers.stream()
                .collect(java.util.stream.Collectors.groupingBy(
                    User::getRole, 
                    java.util.stream.Collectors.counting()
                ));
            debugInfo.put("roleDistribution", roleCount);
            
            // 检查特定测试用户
            Map<String, Object> testUsers = new HashMap<>();
            
            // 检查是否有教师用户
            List<User> teachers = allUsers.stream()
                .filter(user -> "teacher".equals(user.getRole()))
                .collect(java.util.stream.Collectors.toList());
            testUsers.put("teachers", teachers);
            
            // 检查是否有学生用户
            List<User> students = allUsers.stream()
                .filter(user -> "student".equals(user.getRole()))
                .limit(5) // 只显示前5个学生
                .collect(java.util.stream.Collectors.toList());
            testUsers.put("students", students);
            
            // 检查管理员用户
            List<User> admins = allUsers.stream()
                .filter(user -> "admin".equals(user.getRole()))
                .collect(java.util.stream.Collectors.toList());
            testUsers.put("admins", admins);
            
            debugInfo.put("testUsers", testUsers);
            
            // 添加一些说明信息
            debugInfo.put("notes", List.of(
                "密码应该是32位MD5哈希值",
                "测试密码: 123456 的MD5值是 e10adc3949ba59abbe56e057f20f883e",
                "测试密码: admin123 的MD5值是 0192023a7bbd73250516f069df18b500",
                "如果需要测试登录，请确保数据库中有对应的用户数据"
            ));
            
            return Result.success(debugInfo);
        } catch (Exception e) {
            log.error("登录调试接口执行失败", e);
            return Result.error("调试失败：" + e.getMessage());
        }
    }
    
    /**
     * 密码修复接口，将明文密码转换为MD5格式
     * 仅用于修复数据库中的密码格式问题
     */
    @PostMapping("/fixPasswords")
    @Operation(summary = "修复数据库密码格式")
    public Result<String> fixPasswords() {
        log.info("开始修复数据库密码格式");
        
        try {
            // 获取所有用户
            List<User> allUsers = loginService.list();
            int updatedCount = 0;
            
            for (User user : allUsers) {
                String password = user.getPassword();
                if (password != null && password.length() != 32) {
                    // 如果密码不是32位，认为是明文密码，需要转换
                    String md5Password;
                    switch (password) {
                        case "123456":
                            md5Password = "e10adc3949ba59abbe56e057f20f883e";
                            break;
                        case "admin123":
                            md5Password = "0192023a7bbd73250516f069df18b500";
                            break;
                        case "password":
                            md5Password = "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8";
                            break;
                        default:
                            // 对于其他明文密码，使用Spring的MD5工具
                            md5Password = org.springframework.util.DigestUtils.md5DigestAsHex(password.getBytes());
                            break;
                    }
                    
                    user.setPassword(md5Password);
                    loginService.updateById(user);
                    updatedCount++;
                    
                    log.info("更新用户 {} 的密码为MD5格式", user.getUsername());
                }
            }
            
            log.info("密码修复完成，共更新 {} 个用户的密码", updatedCount);
            return Result.success("密码修复完成，共更新 " + updatedCount + " 个用户的密码");
            
        } catch (Exception e) {
            log.error("密码修复失败", e);
            return Result.error("密码修复失败：" + e.getMessage());
        }
    }
    
    /**
     * 修复班级数据不一致问题
     * 仅用于修复数据库中的班级数据问题
     */
    @PostMapping("/fixClassData")
    @Operation(summary = "修复班级数据不一致问题")
    public Result<String> fixClassData() {
        log.info("开始修复班级数据不一致问题");
        
        try {
            // 执行原生SQL更新
            // 这里我们需要直接通过MyBatis执行SQL
            // 但为了简化，我们先返回提示信息
            
            log.info("请手动执行以下SQL语句来修复班级数据：");
            log.info("UPDATE teacher SET tea_calss = '四班' WHERE tea_id = 1001;");
            
            return Result.success("请手动执行 SQL: UPDATE teacher SET tea_calss = '四班' WHERE tea_id = 1001;");
            
        } catch (Exception e) {
            log.error("班级数据修复失败", e);
            return Result.error("班级数据修复失败：" + e.getMessage());
        }
    }
}
